home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / Rectangle.C < prev    next >
C/C++ Source or Header  |  1992-04-27  |  8KB  |  369 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "Rectangle.h"
  6.  
  7. #include "Class.h"
  8. #include "Error.h"
  9. #include "Math.h"
  10. #include "String.h"
  11.  
  12. const Rectangle gRect0;
  13.  
  14. SimpleMetaImpl(Rectangle)
  15. {
  16.     len= len;
  17.     if (! isptr)
  18.     sprintf(buf, "%s", ((Rectangle*) addr)->AsString());
  19. }
  20.  
  21. Rectangle::Rectangle()
  22. {
  23.     origin.x= origin.y= extent.x= extent.y= 0;
  24. }
  25.  
  26. Rectangle::Rectangle(int x, int y, int w, int h)
  27. {
  28.     origin.x= x;
  29.     origin.y= y;
  30.     extent.x= w;
  31.     extent.y= h;
  32. }
  33.  
  34. Rectangle::Rectangle(Point o, Point e)
  35. {
  36.     origin= o;
  37.     extent= e;
  38. }
  39.     
  40. Rectangle::Rectangle(Point e)
  41. {
  42.     origin= 0;
  43.     extent= e;
  44. }
  45.  
  46. Rectangle::Rectangle(int w, int h)
  47. {   
  48.     origin.x= origin.y= 0;
  49.     extent.x= w;
  50.     extent.y= h;
  51. }
  52.  
  53. Rectangle::Rectangle(const Rectangle &r)
  54. {
  55.     origin.x= r.origin.x;
  56.     origin.y= r.origin.y;
  57.     extent.x= r.extent.x;
  58.     extent.y= r.extent.y;
  59. }
  60.  
  61. Rectangle NormRect(Point p1, Point p2)
  62. {
  63.     Rectangle r;
  64.     
  65.     r.origin.x= Math::Min(p1.x, p2.x);
  66.     r.origin.y= Math::Min(p1.y, p2.y);
  67.     r.extent.x= Math::Max(p1.x, p2.x)+1-r.origin.x;
  68.     r.extent.y= Math::Max(p1.y, p2.y)+1-r.origin.y;
  69.     return r;
  70. }
  71.  
  72. bool Rectangle::Intersects(const Rectangle &r) const
  73. {
  74.     return origin.x < r.origin.x + r.extent.x
  75.             && r.origin.x < origin.x + extent.x
  76.             && origin.y < r.origin.y + r.extent.y
  77.             && r.origin.y < origin.y + extent.y;
  78. }
  79.  
  80. bool Rectangle::ContainsRect(const Rectangle &r) const
  81. {
  82.     Point c1= origin + extent, c2= r.origin + r.extent;
  83.     
  84.     return    origin.x <= r.origin.x && c1.x >= c2.x
  85.        && origin.y <= r.origin.y && c1.y >= c2.y;
  86. }
  87.  
  88. bool Rectangle::OvalContainsRect(const Rectangle &r) const
  89. {
  90.     int rad= Math::Min(extent.x, extent.y)/2;
  91.     Point c= Center();
  92.     
  93.     if (Length(r.NW()-c) >= rad)
  94.     return FALSE;
  95.     if (Length(r.NE()-c) >= rad)
  96.     return FALSE;
  97.     if (Length(r.SW()-c) >= rad)
  98.     return FALSE;
  99.     if (Length(r.SE()-c) >= rad)
  100.     return FALSE;
  101.     return TRUE;
  102. }
  103.  
  104. Rectangle Rectangle::Merge(const Rectangle &r)
  105. { 
  106.     register int x1, x2, y1, y2;
  107.     
  108.     if (IsEmpty())
  109.     return *this= r;
  110.     if (r.IsEmpty())
  111.     return *this;
  112.     x1= origin.x + extent.x; 
  113.     y1= origin.y + extent.y; 
  114.     x2= r.origin.x + r.extent.x; 
  115.     y2= r.origin.y + r.extent.y; 
  116.     origin.x= Math::Min(origin.x, r.origin.x);
  117.     origin.y= Math::Min(origin.y, r.origin.y);
  118.     extent.x= Math::Max(x1, x2) - origin.x;
  119.     extent.y= Math::Max(y1, y2) - origin.y;
  120.     return *this;
  121. }
  122.  
  123. Rectangle Union(const Rectangle &r1, const Rectangle &r2)
  124. {
  125.     Rectangle rr= r1;
  126.     return rr.Merge(r2);
  127. }
  128.  
  129. bool Rectangle::Clip(const Rectangle &r)
  130. {
  131.     register int p1x, p1y, p2x, p2y;
  132.     
  133.     if (IsEmpty())
  134.     return FALSE;
  135.     if (r.IsEmpty()) { 
  136.     *this= gRect0; // g++ 1.37.2.beta bug on 68020 cpu ?
  137.     return FALSE;
  138.     }
  139.     p1x= origin.x + extent.x;
  140.     p1y= origin.y + extent.y;
  141.     p2x= r.origin.x + r.extent.x;
  142.     p2y= r.origin.y + r.extent.y;
  143.     origin.x= Math::Max(origin.x, r.origin.x);
  144.     origin.y= Math::Max(origin.y, r.origin.y);
  145.     extent.x= Math::Min(p1x, p2x) - origin.x;
  146.     extent.y= Math::Min(p1y, p2y) - origin.y;
  147.     return IsNotEmpty();
  148. }
  149.  
  150. Rectangle Inter(Rectangle r1, const Rectangle &r2)
  151. {
  152.     r1.Clip(r2);
  153.     return r1;
  154. }
  155.  
  156. Rectangle Rectangle::Intersect(const Rectangle &r)
  157. {
  158.     Clip(r);
  159.     return *this;
  160. }
  161.  
  162. Rectangle BoundingBox(int npts, Point *pts, Point *np)
  163. {
  164.     Point mi= pts[0], ma= pts[0];
  165.     Rectangle r;
  166.     register int i;
  167.     
  168.     if (np == 0)
  169.     np= pts;
  170.     
  171.     for (i= 1; i<npts; i++) {
  172.     mi= Min(mi, pts[i]);
  173.     ma= Max(ma, pts[i]);
  174.     }
  175.     r.origin= mi;
  176.     r.extent= ma-mi+1;
  177.     for (i= 0; i<npts; i++)
  178.     np[i]= pts[i]-mi;
  179.     
  180.     return r;
  181. }
  182.  
  183. Rectangle Rectangle::WedgeBBox(int s, int d)
  184. {
  185.     Point mi, ma, p;
  186.     register int i;
  187.     
  188.     if (d >= 270)
  189.     return *this;
  190.     
  191.     mi= ma= Center();
  192.     p= AngleToPoint(s);
  193.     mi= Min(p, mi);
  194.     ma= Max(p, ma);
  195.     i= 1;
  196.     for (i= 1; i < d-1; i++) {
  197.     switch (s+i) {
  198.     case 0:
  199.         mi.y= origin.y;
  200.         break;
  201.     case 90:
  202.         ma.x= origin.x + extent.x;
  203.         break;
  204.     case 180:
  205.         ma.y= origin.y + extent.y;
  206.         break;
  207.     case 270:
  208.         mi.x= origin.x;
  209.         break;
  210.     default:
  211.         continue;
  212.     }
  213.     }
  214.     p= AngleToPoint(s+d);
  215.     return NormRect(Min(p, mi), Max(p, ma));
  216. }
  217.  
  218. int Difference(Rectangle *rp, const Rectangle &r1, const Rectangle &ra)
  219. {
  220.     register int p2x, p2y;
  221.     Rectangle r2, dr[4];
  222.     int n, i;
  223.  
  224.     r2= Inter(r1, ra);
  225.     if (r2.IsNotEmpty()) {
  226.     p2x= r2.origin.x+r2.extent.x;
  227.     p2y= r2.origin.y+r2.extent.y;
  228.     
  229.     dr[0].origin= r1.origin;
  230.     dr[0].extent.x= r1.extent.x;
  231.     dr[0].extent.y= r2.origin.y-r1.origin.y;
  232.     
  233.     dr[1].origin.x= r1.origin.x;
  234.     dr[1].origin.y= r2.origin.y;
  235.     dr[1].extent.x= r2.origin.x-r1.origin.x;
  236.     dr[1].extent.y= r2.extent.y;
  237.     
  238.     dr[2].origin.x= p2x;
  239.     dr[2].origin.y= r2.origin.y;
  240.     dr[2].extent.x= r1.origin.x+r1.extent.x-p2x;
  241.     dr[2].extent.y= r2.extent.y;
  242.     
  243.     dr[3].origin.x= r1.origin.x;
  244.     dr[3].origin.y= p2y;
  245.     dr[3].extent.x= r1.extent.x;
  246.     dr[3].extent.y= r1.origin.y+r1.extent.y-p2y;
  247.     } else 
  248.     dr[0]= r1;
  249.     
  250.     for (n= i= 0; i<4; i++)
  251.     if (dr[i].IsNotEmpty())
  252.         rp[n++]= dr[i];
  253.     return n;
  254. }
  255.  
  256. Rectangle Rectangle::Inset(Point p)
  257. {
  258.     Rectangle r;
  259.     
  260.     r.origin.x= origin.x + p.x;
  261.     r.origin.y= origin.y + p.y;
  262.     r.extent.x= extent.x - 2 * p.x;
  263.     r.extent.y= extent.y - 2 * p.y;
  264.     return r;
  265. }
  266.  
  267. Rectangle Rectangle::Expand(Point p)
  268. {
  269.     Rectangle r;
  270.     
  271.     r.origin.x= origin.x - p.x;
  272.     r.origin.y= origin.y - p.y;
  273.     r.extent.x= extent.x + 2 * p.x;
  274.     r.extent.y= extent.y + 2 * p.y;
  275.     return r;
  276. }
  277.         
  278. Point Rectangle::Constrain(Point p)
  279. {
  280.     p= Min(p, origin+extent);
  281.     return Max(p, origin);
  282. }
  283.         
  284. Point ConstrainMoveRect(const Rectangle &r1, const Rectangle &r2, Point delta)
  285. {
  286.     Point p= r1.origin + r1.extent - r2.extent;
  287.     p= Min(p, r2.origin+delta);
  288.     return Max(r1.origin, p)-r2.origin;
  289. }
  290.  
  291. Point Rectangle::AmountToTranslateWithin(const Rectangle &r)
  292. {
  293.     Point delta(0), rUL= NW(), rLR= SE(), vrUL= r.NW(), vrLR= r.SE();
  294.     
  295.     for (int v= 0; v <= 1; v++) {
  296.     if (rUL[v] < vrUL[v] && rLR[v] > vrLR[v])
  297.         continue;
  298.     if (rLR[v] - vrUL[v] < extent[v])
  299.         delta[v]= vrUL[v] - rUL[v];
  300.     if (vrLR[v] - rUL[v] < extent[v])
  301.         delta[v]= vrLR[v] - rLR[v];
  302.     }
  303.     return delta;
  304. }
  305.  
  306. OStream& operator<< (OStream &s, const Rectangle &r)
  307. {
  308.     return s << r.origin << r.extent;
  309. }                  
  310.  
  311. IStream& operator>> (IStream &s, Rectangle &r)
  312. {
  313.     return s >> r.origin >> r.extent;
  314. }
  315.  
  316. int Rectangle::PointToAngle(Point p) const
  317. {
  318.     p-= Center();
  319.     return (int) Math::Atan2(p.y*extent.x, p.x*extent.y);
  320. }
  321.  
  322. Point Rectangle::OvalAngleToPoint(int ang) const
  323. {
  324.     return Center() + PolarToPoint(ang, extent.x/2, extent.y/2);
  325. }
  326.  
  327. Point Rectangle::AngleToPoint(int a) const
  328. {
  329.     double si, co;
  330.     register int x= 0, y= 0;
  331.  
  332.     Math::Sincos(a, &si, &co);
  333.     
  334.     if (si != 0.0) {
  335.     x= (int) ((1.0 + co/Math::Abs(si))/2.0 * extent.x);
  336.     x= Math::Range(0, extent.x, x);
  337.     } else if (co >= 0.0)
  338.     x= extent.x;
  339.     if (co != 0.0) {
  340.     y= (int) ((1.0 + si/Math::Abs(co))/2.0 * extent.y);
  341.     y= Math::Range(0, extent.y, y);
  342.     } else if (si >= 0.0)
  343.     y= extent.y;
  344.     return origin + Point(x, y);
  345. }
  346.  
  347. // Corners:
  348. //         7|0|1
  349. //        -------
  350. //         6| |2
  351. //        -------
  352. //         5|4|3
  353.  
  354. int Rectangle::PointToCorner(Point p) const
  355. {
  356.     return ((PointToAngle(p)+22)/45) % 8;
  357. }
  358.  
  359. Point Rectangle::CornerToPoint(int n) const
  360. {
  361.     return AngleToPoint((n % 8)*45);
  362. }
  363.  
  364. char *Rectangle::AsString() const
  365. {
  366.     return form("x: %d y: %d w: %d h: %d", origin.x, origin.y, extent.x, extent.y);
  367. }
  368.  
  369.